package demo02ClassObj;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User:咭咭熊
 * Date:2021 - 09 - 09
 * Time:10:32
 */

/***
 * 一、类和对象
 * 定义类：class 类名{
 *     字段：filed【定义在类的内部，方法的外部】
 *     方法：method
 * }
 * 1.属性(字段、属性、成员变量)、方法
 * 2.静态成员变量存储在方法区；
 * 3.成员变量定义在类的内部需，方法的外部；
 * 成员变量如果没有进行初始化，那么他的值就是一个默认值;
 * 引用类型，值就是null;
 * 简单类型，值就是其这种类型所对应的默认值
 * byte——0 short——0 int——0 long——0L
 * float ——0.0f  double——0.0
 * char——‘/u0000’
 * boolean——false
 *
 * 4.对于静态的未成年元变量和静态成员方法的访问：类名.变量名、类名.方法名；
 *      对于静态的属性或者方法是不依赖于对象的；——为什么main方法是静态的
 *
 *  5.访问权限定符：public protected、private、默认权限
 *
 *  6.对象时如何产生的？——实例化
 *
 *  7.当使用sout打印一个引用的时候，那么默认就会调用Object的toString()方法
 *
 *  8.访问形式：
 *  （1）如果是实例成员变量，访问形式是：通过对象的引用来进行访问呢；
 *  （2）如果是静态成员变量：访问形式是：通过类名.变量名
 *
 *  9.问题：静态的成员变量或者成员党发是否可以通过对象的引用来进行访问？
 *  可以，但是合法不合理，建议规范都是类名去访问；
 *
 *
 *  10.一个类可以产生/实例化多个对象；通过new关键字；
 *
 *  11.初始化成员变量的方式：
 *  （1）就地初始化；
 *  （2）默认初始化；
 *  （3）在类外进行初始化
 *
 *  12.static关键字：
 *  （1）可以修饰属性；——Java静态属性和类相关，与具体的实例无关
 *  （2）可以修饰方法；
 *  （3）可以修饰代码块；
 *  （4）可以修饰类【内部类】
 *
 *  13.
 *   (1）静态方法属于类，而不属于类的对象；
 *  （2）可以直接调用静态方法，而无需创建类的实例；
 *  （3）静态方法可以访问静态数据成员，并可以更改静态数据成员变量；
 *
 *  14.在静态方法内部是不可以 访问非静态成员变量；
 *
 *  15.
 */
class Person{//成员变量的定义位置：类的内部，方法的外部
    //name,age ,a称为属性、字段、成员变量
    //name,age——实例成员变量
    //name,age ——存放在堆上
    public String name;
    public int age;
    //类变量也叫静态变量；——存储在方法区
    public static int  count= 10;//静态成员变量——存储于方法区,类属性
    public int size;
    //size1被final修饰，——属于变量，只能修改一次——存放在堆上—；
    public  int size1 = 20;
    //count1——被static final修饰——存放在方法区——只保存一份
    public  static final int count1 = 99;


    //行为，方法
    public void eat(){//普通成员方法【实例成员方法】
        int a= 10;//局部变量
        System.out.println("吃饭。。。");
    }
    public void sleep(){
        System.out.println("睡觉。。。。");
    }
    public static void func(){//静态成员方法
        System.out.println("静态成员方法func()。。。。");
    }

    /**
     * 打印成员变量以及方法
     */
/*    public void show(){
        System.out.println("姓名：" + name + "年龄：" + age);
    }*/

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", size=" + size +
                '}';
    }
}
public class TestDemo01 {








    /***
     * 9.
     * @param args
     */
    public static void main9(String[] args) {
        Person person1 = null;//代表此引用不指向任何对象
 /*       Person person2 = new Person();
        person1 = person2;//person1指向了person2所指向的对象
    */
        System.out.println(person1.age);//会出现空指针异常
    }
    /***
     * 8.toString()方法
     * @param args
     */
    public static void main8(String[] args) {
        Person person1 = new Person();
        person1.name = "张三";
        person1.age = 20;
        System.out.println(person1);
    }
    /***
     * 7.
     * （1）静态的成员属性或者静态的成员方法是不依赖于对象的；
     * （2）静态的成员变量只有一份，存在方法区当中；
     * （3)主函数main()函数是静态的，在使用的时候是不需要new对象的，直接进行调用；静态的不依赖于对象；
     *
     * @param args
     */
    public static void main7(String[] args) {
        Person person1 = new Person();
        person1.size++;
        Person person2 = new Person();
        person2.size++;
        Person person3 = new Person();
        person3.size++;
        System.out.println(person3.size);//1

        Person person4 = new Person();
        person4.count++;
        Person person5 = new Person();
        person5.count++;
        Person person6= new Person();
        person6.count++;
        System.out.println(person6.count);//3

    }
    /***
     * 6.初始化成员变量的3种方式
     * @param args
     */
    public static void main6(String[] args) {
        //方式3：在类外进行初始化
        Person person1 = new Person();
        person1.name = "zhangsan";
        person1.age = 16;
        person1.eat();
        System.out.println(person1.name);
        System.out.println(person1.age);

        Person person2 = new Person();
        person2.name = "lisi";
        person2.age = 20;
        person2.eat();
        System.out.println(person2.name);
        System.out.println(person2.age);
    }
    /***
     * 5.对象是如何产生的？——实例化
     * 当使用sout打印一个引用的时候，那么默认就会调用Object的toString()方法
     * @param args
     */
    public static void main5(String[] args) {
        //实例化了一个对象
        Person person = new Person();
        //person是一个引用——存储了new Person这个对象的地址
        System.out.println(person);//Person@1b6d3586【引用的类型@真实的地址的二哈哈希值】
        //调用toString()返回的是getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
    /***
     * 4.为什么main方法是静态的
     * @param args
     */
/*    public *//*static*//* void main(String[] args) {
        TestDemo01 testDemo01 = new TestDemo01();
        String[] strs = {};
        testDemo01.main(strs);
    }*/
    public static void main4(String[] args) {
        //将main方法设置为静态的，不需要new对象了；可直接进行方法的调用
        String[] strs = {};
        main4(strs);
    }
    /***
     * 3.对于静态成员变量的访问：类名.变量名
     * @param args
     */
    public static void main3(String[] args) {
        System.out.println(Person.count);
        Person.func();
    }

    /***
     * 2.对成员变量进行赋值
     * @param args
     */
    public static void main2(String[] args) {
        Person person = new Person();
        person.name = "java";
        person.age = 10;
        System.out.println(person.name);
        System.out.println(person.age);

        person.eat();
        person.sleep();
    }
    public static void main1(String[] args) {

        //实例化对象
        //person是一个引用
        Person person = new Person();
        System.out.println(person.name);//null
        System.out.println(person.age);//0
    }
}
